package com.core.ingenium.model;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import javax.persistence.Query;


public class JavaServiceFacade {
    private static final boolean isAutoCommit = true;
    private final EntityManagerHelper entityManagerHelper;

    public JavaServiceFacade() {
        entityManagerHelper = new EntityManagerHelper("Model-1", isAutoCommit);
    }

    public Object queryByRange(String jpqlStmt, int firstResult, int maxResults) {
        Query query = entityManagerHelper.getEntityManager().createQuery(jpqlStmt);
        if (firstResult > 0) {
            query = query.setFirstResult(firstResult);
        }
        if (maxResults > 0) {
            query = query.setMaxResults(maxResults);
        }
        return query.getResultList();
    }

    public Permiso persistPermiso(Permiso permiso) {
        return (Permiso)entityManagerHelper.persistEntity(permiso);
    }

    public Permiso mergePermiso(Permiso permiso) {
        return (Permiso)entityManagerHelper.mergeEntity(permiso);
    }

    public void removePermiso(Permiso permiso) {
        permiso = entityManagerHelper.getEntityManager().find(Permiso.class, permiso.getId());
        entityManagerHelper.removeEntity(permiso);
    }

    /** <code>select o from Permiso o</code> */
    public List<Permiso> getPermisoFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Permiso.findAll").getResultList();
    }

    public Nivel persistNivel(Nivel nivel) {
        return (Nivel)entityManagerHelper.persistEntity(nivel);
    }

    public Nivel mergeNivel(Nivel nivel) {
        return (Nivel)entityManagerHelper.mergeEntity(nivel);
    }

    public void removeNivel(Nivel nivel) {
        nivel = entityManagerHelper.getEntityManager().find(Nivel.class, nivel.getId());
        entityManagerHelper.removeEntity(nivel);
    }

    /** <code>select o from Nivel o</code> */
    public List<Nivel> getNivelFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Nivel.findAll").getResultList();
    }

    public Bitacora persistBitacora(Bitacora bitacora) {
        return (Bitacora)entityManagerHelper.persistEntity(bitacora);
    }

    public Bitacora mergeBitacora(Bitacora bitacora) {
        return (Bitacora)entityManagerHelper.mergeEntity(bitacora);
    }

    public void removeBitacora(Bitacora bitacora) {
        bitacora = entityManagerHelper.getEntityManager().find(Bitacora.class, bitacora.getId());
        entityManagerHelper.removeEntity(bitacora);
    }

    /** <code>select o from Bitacora o</code> */
    public List<Bitacora> getBitacoraFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Bitacora.findAll").getResultList();
    }

    public ResultadoSeccion persistResultadoSeccion(ResultadoSeccion resultadoSeccion) {
        return (ResultadoSeccion)entityManagerHelper.persistEntity(resultadoSeccion);
    }

    public ResultadoSeccion mergeResultadoSeccion(ResultadoSeccion resultadoSeccion) {
        return (ResultadoSeccion)entityManagerHelper.mergeEntity(resultadoSeccion);
    }

    public void removeResultadoSeccion(ResultadoSeccion resultadoSeccion) {
        resultadoSeccion = entityManagerHelper.getEntityManager().find(ResultadoSeccion.class, resultadoSeccion.getId());
        entityManagerHelper.removeEntity(resultadoSeccion);
    }

    /** <code>select o from ResultadoSeccion o</code> */
    public List<ResultadoSeccion> getResultadoSeccionFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("ResultadoSeccion.findAll").getResultList();
    }

    public PermisoRol persistPermisoRol(PermisoRol permisoRol) {
        return (PermisoRol)entityManagerHelper.persistEntity(permisoRol);
    }

    public PermisoRol mergePermisoRol(PermisoRol permisoRol) {
        return (PermisoRol)entityManagerHelper.mergeEntity(permisoRol);
    }

    public void removePermisoRol(PermisoRol permisoRol) {
        permisoRol = entityManagerHelper.getEntityManager().find(PermisoRol.class, permisoRol.getId());
        entityManagerHelper.removeEntity(permisoRol);
    }

    /** <code>select o from PermisoRol o</code> */
    public List<PermisoRol> getPermisoRolFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("PermisoRol.findAll").getResultList();
    }

    public UsuarioCarrera persistUsuarioCarrera(UsuarioCarrera usuarioCarrera) {
        return (UsuarioCarrera)entityManagerHelper.persistEntity(usuarioCarrera);
    }

    public UsuarioCarrera mergeUsuarioCarrera(UsuarioCarrera usuarioCarrera) {
        return (UsuarioCarrera)entityManagerHelper.mergeEntity(usuarioCarrera);
    }

    public void removeUsuarioCarrera(UsuarioCarrera usuarioCarrera) {
        usuarioCarrera = entityManagerHelper.getEntityManager().find(UsuarioCarrera.class, usuarioCarrera.getId());
        entityManagerHelper.removeEntity(usuarioCarrera);
    }

    /** <code>select o from UsuarioCarrera o</code> */
    public List<UsuarioCarrera> getUsuarioCarreraFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("UsuarioCarrera.findAll").getResultList();
    }

    public Usuario persistUsuario(Usuario usuario) {
        return (Usuario)entityManagerHelper.persistEntity(usuario);
    }

    public Usuario mergeUsuario(Usuario usuario) {
        return (Usuario)entityManagerHelper.mergeEntity(usuario);
    }

    public void removeUsuario(Usuario usuario) {
        usuario = entityManagerHelper.getEntityManager().find(Usuario.class, usuario.getId());
        entityManagerHelper.removeEntity(usuario);
    }

    /** <code>select o from Usuario o</code> */
    public List<Usuario> getUsuarioFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Usuario.findAll").getResultList();
    }

   
    public EstudiantePlantilla persistEstudiantePlantilla(EstudiantePlantilla estudiantePlantilla) {
        return (EstudiantePlantilla)entityManagerHelper.persistEntity(estudiantePlantilla);
    }

    public EstudiantePlantilla mergeEstudiantePlantilla(EstudiantePlantilla estudiantePlantilla) {
        return (EstudiantePlantilla)entityManagerHelper.mergeEntity(estudiantePlantilla);
    }

    public void removeEstudiantePlantilla(EstudiantePlantilla estudiantePlantilla) {
        estudiantePlantilla = entityManagerHelper.getEntityManager().find(EstudiantePlantilla.class, estudiantePlantilla.getId());
        entityManagerHelper.removeEntity(estudiantePlantilla);
    }

    /** <code>select o from EstudiantePlantilla o</code> */
    public List<EstudiantePlantilla> getEstudiantePlantillaFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("EstudiantePlantilla.findAll").getResultList();
    }

    /** <code>select o from EstudiantePlantilla o where o.estudiante.identificacion = :pid</code> */
    public EstudiantePlantilla getEstudiantePlantillaFindByEstudiante(Estudiante estudiante) {
        Query q = entityManagerHelper.getEntityManager().createNamedQuery("EstudiantePlantilla.findByEstudiante");
        q.setParameter("pid", estudiante.getIdentificacion());//parametro 1
        return (EstudiantePlantilla)q.getSingleResult();
    }

    public Estudiante persistEstudiante(Estudiante estudiante) {
        return (Estudiante)entityManagerHelper.persistEntity(estudiante);
    }

    public Estudiante mergeEstudiante(Estudiante estudiante) {
        return (Estudiante)entityManagerHelper.mergeEntity(estudiante);
    }

    public void removeEstudiante(Estudiante estudiante) {
        estudiante = entityManagerHelper.getEntityManager().find(Estudiante.class, estudiante.getId());
        entityManagerHelper.removeEntity(estudiante);
    }

    /** <code>select o from Estudiante o</code> */
    public List<Estudiante> getEstudianteFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Estudiante.findAll").getResultList();
    }

    /** <code>select o from Estudiante o where o.identificacion = :pid</code> */
    public Estudiante getEstudianteFindByIdentificacion(Estudiante estudiante) {
        Query q = entityManagerHelper.getEntityManager().createNamedQuery("Estudiante.findByIdentificacion");
        q.setParameter("pidentificacion", estudiante.getIdentificacion());//parametro 1
        return (Estudiante)q.getSingleResult();
    }
    /** <code>select o from Estudiante o where o.nombre like :pfiltro or o.apellido1 like :pfiltro or o.apellido2 like :pfiltro</code> */
    public List<Estudiante> getEstudianteFindByFiltro(Estudiante estudiante){
        Query q = entityManagerHelper.getEntityManager().createNamedQuery("Estudiante.findByFiltro");
        q.setParameter("pfiltro", "%"+estudiante.getNombre()+"%");
        return (List)q.getResultList();
    }

    public Seccion persistSeccion(Seccion seccion) {
        return (Seccion)entityManagerHelper.persistEntity(seccion);
    }

    public Seccion mergeSeccion(Seccion seccion) {
        return (Seccion)entityManagerHelper.mergeEntity(seccion);
    }

    public void removeSeccion(Seccion seccion) {
        seccion = entityManagerHelper.getEntityManager().find(Seccion.class, seccion.getId());
        entityManagerHelper.removeEntity(seccion);
    }

    /** <code>select o from Seccion o</code> */
    public List<Seccion> getSeccionFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Seccion.findAll").getResultList();
    }

    public CarreraNivel persistCarreraNivel(CarreraNivel carreraNivel) {
        return (CarreraNivel)entityManagerHelper.persistEntity(carreraNivel);
    }

    public CarreraNivel mergeCarreraNivel(CarreraNivel carreraNivel) {
        return (CarreraNivel)entityManagerHelper.mergeEntity(carreraNivel);
    }

    public void removeCarreraNivel(CarreraNivel carreraNivel) {
        carreraNivel = entityManagerHelper.getEntityManager().find(CarreraNivel.class, carreraNivel.getId());
        entityManagerHelper.removeEntity(carreraNivel);
    }

    /** <code>select o from CarreraNivel o</code> */
    public List<CarreraNivel> getCarreraNivelFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("CarreraNivel.findAll").getResultList();
    }

    public Plantilla persistPlantilla(Plantilla plantilla) {
        return (Plantilla)entityManagerHelper.persistEntity(plantilla);
    }

    public Plantilla mergePlantilla(Plantilla plantilla) {
        return (Plantilla)entityManagerHelper.mergeEntity(plantilla);
    }

    public void removePlantilla(Plantilla plantilla) {
        plantilla = entityManagerHelper.getEntityManager().find(Plantilla.class, plantilla.getId());
        entityManagerHelper.removeEntity(plantilla);
    }

    /** <code>select o from Plantilla o</code> */
    public List<Plantilla> getPlantillaFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Plantilla.findAll").getResultList();
    }

    public Opcion persistOpcion(Opcion opcion) {
        return (Opcion)entityManagerHelper.persistEntity(opcion);
    }

    public Opcion mergeOpcion(Opcion opcion) {
        return (Opcion)entityManagerHelper.mergeEntity(opcion);
    }

    public void removeOpcion(Opcion opcion) {
        opcion = entityManagerHelper.getEntityManager().find(Opcion.class, opcion.getId());
        entityManagerHelper.removeEntity(opcion);
    }

    /** <code>select o from Opcion o</code> */
    public List<Opcion> getOpcionFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Opcion.findAll").getResultList();
    }

    public Pregunta persistPregunta(Pregunta pregunta) {
        return (Pregunta)entityManagerHelper.persistEntity(pregunta);
    }

    public Pregunta mergePregunta(Pregunta pregunta) {
        return (Pregunta)entityManagerHelper.mergeEntity(pregunta);
    }

    public void removePregunta(Pregunta pregunta) {
        pregunta = entityManagerHelper.getEntityManager().find(Pregunta.class, pregunta.getId());
        entityManagerHelper.removeEntity(pregunta);
    }

    /** <code>select o from Pregunta o</code> */
    public List<Pregunta> getPreguntaFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Pregunta.findAll").getResultList();
    }

    public Rol persistRol(Rol rol) {
        return (Rol)entityManagerHelper.persistEntity(rol);
    }

    public Rol mergeRol(Rol rol) {
        return (Rol)entityManagerHelper.mergeEntity(rol);
    }

    public void removeRol(Rol rol) {
        rol = entityManagerHelper.getEntityManager().find(Rol.class, rol.getId());
        entityManagerHelper.removeEntity(rol);
    }

    /** <code>select o from Rol o</code> */
    public List<Rol> getRolFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Rol.findAll").getResultList();
    }

    public Carrera persistCarrera(Carrera carrera) {
        return (Carrera)entityManagerHelper.persistEntity(carrera);
    }

    public Carrera mergeCarrera(Carrera carrera) {
        return (Carrera)entityManagerHelper.mergeEntity(carrera);
    }

    public void removeCarrera(Carrera carrera) {
        carrera = entityManagerHelper.getEntityManager().find(Carrera.class, carrera.getId());
        entityManagerHelper.removeEntity(carrera);
    }

    /** <code>select o from Carrera o</code> */
    public List<Carrera> getCarreraFindAll() {
        return entityManagerHelper.getEntityManager().createNamedQuery("Carrera.findAll").getResultList();
    }

    private class EntityManagerHelper {
        final private EntityManagerFactory _entityManagerFactory;
        final private boolean _isAutoCommit;

        private EntityManager _entityManager;

        EntityManagerHelper(String persistenceUnit, boolean isAutoCommit) {
            _entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnit);
            _isAutoCommit = isAutoCommit;
        }

        public EntityManager getEntityManager() {
            if (_entityManager == null) {
                _entityManager = _entityManagerFactory.createEntityManager();
            }

            return _entityManager;
        }

        public EntityTransaction getEntityTransaction() {
            return getEntityManager().getTransaction();
        }

        public void commitTransaction() {
            final EntityTransaction entityTransaction = getEntityTransaction();
            if (entityTransaction.isActive()) {
                entityTransaction.commit();
            }

            _closeEntityManager();
        }

        public void rollbackTransaction() {
            final EntityTransaction entityTransaction = getEntityTransaction();
            if (entityTransaction.isActive()) {
                entityTransaction.rollback();
            }

            _closeEntityManager();
        }

        public boolean isTransactionDirty() {
            return (!_isAutoCommit && getEntityTransaction().isActive());
        }

        public Object persistEntity(Object entity) {
            _beginTransactionIfNeeded();
            _entityManager.persist(entity);
            _commitTransactionIfNeeded();

            return entity;
        }

        public Object mergeEntity(Object entity) {
            _beginTransactionIfNeeded();
            entity = _entityManager.merge(entity);
            _commitTransactionIfNeeded();

            return entity;
        }

        public void removeEntity(Object entity) {
            _beginTransactionIfNeeded();
            _entityManager.remove(entity);
            _commitTransactionIfNeeded();
        }

        private void _beginTransactionIfNeeded() {
            final EntityTransaction entityTransaction = getEntityTransaction();
            if (!entityTransaction.isActive()) {
                entityTransaction.begin();
            }
        }

        private void _commitTransactionIfNeeded() {
            if (_isAutoCommit) {
                commitTransaction();
            }
        }

        private void _closeEntityManager() {
            if (_entityManager != null && _entityManager.isOpen()) {
                _entityManager.close();
            }

            _entityManager = null;
        }
    }
}
